package net.ck.hzq;

import android.app.Activity;
import android.content.Context;
import android.graphics.Point;
import android.os.Build;
import android.os.StrictMode;
import android.support.multidex.MultiDexApplication;
import android.util.Log;

import com.facebook.cache.disk.DiskCacheConfig;
import com.facebook.common.internal.Supplier;
import com.facebook.common.util.ByteConstants;
import com.facebook.drawee.backends.pipeline.Fresco;
import com.facebook.imagepipeline.backends.okhttp.OkHttpImagePipelineConfigFactory;
import com.facebook.imagepipeline.cache.MemoryCacheParams;
import com.facebook.imagepipeline.core.ImagePipelineConfig;
import com.kf5.sdk.system.init.KF5SDKInitializer;
import com.mob.MobSDK;
import com.msd.ocr.idcard.LibraryInitOCR;
import com.squareup.okhttp.OkHttpClient;
import com.umeng.commonsdk.UMConfigure;
import com.umeng.message.IUmengRegisterCallback;
import com.umeng.message.PushAgent;

import java.io.File;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import Utils.SharedPrefStore;
import Utils.ToastUtil;
import ui.activity.poscontrol.beanmodel.TiXianResultBean;
import ui.activity.profit.biz.ProfitBiz;
import util.SysUtils;

public class TobuyApplication extends MultiDexApplication {

    public static final int MAX_HEAP_SIZE = (int) Runtime.getRuntime().maxMemory();//分配的可用内存
    public static final int MAX_MEMORY_CACHE_SIZE = MAX_HEAP_SIZE / 4;//使用的缓存数量

    public static final int MAX_SMALL_DISK_VERYLOW_CACHE_SIZE = 5 * ByteConstants.MB;//小图极低磁盘空间缓存的最大值（特性：可将大量的小图放到额外放在另一个磁盘空间防止大图占用磁盘空间而删除了大量的小图）
    public static final int MAX_SMALL_DISK_LOW_CACHE_SIZE = 10 * ByteConstants.MB;//小图低磁盘空间缓存的最大值（特性：可将大量的小图放到额外放在另一个磁盘空间防止大图占用磁盘空间而删除了大量的小图）
    public static final int MAX_SMALL_DISK_CACHE_SIZE = 20 * ByteConstants.MB;//小图磁盘缓存的最大值（特性：可将大量的小图放到额外放在另一个磁盘空间防止大图占用磁盘空间而删除了大量的小图）

    public static final int MAX_DISK_CACHE_VERYLOW_SIZE = 10 * ByteConstants.MB;//默认图极低磁盘空间缓存的最大值
    public static final int MAX_DISK_CACHE_LOW_SIZE = 30 * ByteConstants.MB;//默认图低磁盘空间缓存的最大值
    public static final int MAX_DISK_CACHE_SIZE = 50 * ByteConstants.MB;//默认图磁盘缓存的最大值


    public static final String IMAGE_PIPELINE_SMALL_CACHE_DIR = "tobuyapplicationsmall_cache";//小图所放路径的文件夹名
    public static final String IMAGE_PIPELINE_CACHE_DIR = "tobuyapplication_cache";//默认图所放路径的文件夹名

    public static String imgPath;

    public static Point point;

    public static Context context;

    public static List<TiXianResultBean> resultBeans;

    public static String customId;
    public static String youmengtoken;
    public static String token;
    public static boolean isPiliang=false;
    public static List<String> piliangPosition= new ArrayList<>();//回拨批量处理存储下表

    public static TobuyApplication getmInstance() {
        return mInstance;
    }

    private ProfitBiz biz;
    public static void setmInstance(TobuyApplication mInstance) {
        TobuyApplication.mInstance = mInstance;
    }

    private static TobuyApplication mInstance = null;


    public static String getCustomId(){
        if(null != customId&&customId.length()>0){
            return  customId;
        }else {
            SharedPrefStore store = new SharedPrefStore();
            customId = store.getString("id", "0");
            return customId;
        }
    }
    @Override
    public void onCreate() {
        super.onCreate();

        biz = new ProfitBiz();
        context = getApplicationContext();
//        UMConfigure.init(this, UMConfigure.DEVICE_TYPE_PHONE, "5c91d66361f564c24f000079");


// 在此处调用基础组件包提供的初始化函数 相应信息可在应用管理 -> 应用信息 中找到 http://message.umeng.com/list/apps
// 参数一：当前上下文context；
// 参数二：应用申请的Appkey（需替换）；
// 参数三：渠道名称；
// 参数四：设备类型，必须参数，传参数为UMConfigure.DEVICE_TYPE_PHONE则表示手机；传参数为UMConfigure.DEVICE_TYPE_BOX则表示盒子；默认为手机；
// 参数五：Push推送业务的secret 填充Umeng Message Secret对应信息（需替换）

//                UmengMessageHandler messageHandler = new UmengMessageHandler() {
//
//            @Override
//            public Notification getNotification(Context context, UMessage msg) {
//
//                for (Map.Entry entry : msg.extra.entrySet()) {
//
//                    Object key = entry.getKey();
//                    Object value = entry.getValue();
//                    Log.e("fjs","Canshu：-------->  " + "s:" + key + ",s1:" + value);
//
//                }
//                return super.getNotification(context, msg);
//            }
//        };
//        mPushAgent.setMessageHandler(messageHandler);


        mInstance = this;

    }

    public static TobuyApplication getInstance() {
        if (null == mInstance) {
            mInstance = new TobuyApplication();
        }
        return mInstance;
    }


    private LinkedList<Activity> mActivitys = new LinkedList<Activity>();

    public void onActivityCreate(Activity activity) {
        try {
            if (mActivitys.size() != 0) {
                for (int i = 0; i < mActivitys.size(); i++) {
                    if (mActivitys.get(i).getClass() == activity.getClass()) {
                        break;
                    } else {
                        if (i == mActivitys.size() - 1) {
                            mActivitys.add(activity);
                        }
                    }
                }
            } else {
                mActivitys.add(activity);
            }
        } catch (Exception e) {

        }
    }

    public void onActivityDestroy(Activity activity) {
        mActivitys.remove(activity);
    }

    public static boolean isAuthed() {
        SharedPrefStore store = new SharedPrefStore();
        return store.getString("isRealNameAuthenticationed", "0").equals("1");
    }

    public void finishAllActivity() {
        for (Activity activity : mActivitys) {
            if (!activity.isFinishing()) {
                activity.finish();
            }
        }
    }

    private void initFresco() {
        imgPath = SysUtils.getExternalSdCardPath();
        if (imgPath == null) {
            imgPath = getFilesDir().getAbsolutePath();
        }
        //内存配置
        final MemoryCacheParams bitmapCacheParams = new MemoryCacheParams(
                MAX_MEMORY_CACHE_SIZE, // 内存缓存中总图片的最大大小,以字节为单位。
                Integer.MAX_VALUE, // 内存缓存中图片的最大数量。
                MAX_MEMORY_CACHE_SIZE, // 内存缓存中准备清除但尚未被删除的总图片的最大大小,以字节为单位。
                Integer.MAX_VALUE, // 内存缓存中准备清除的总图片的最大数量。
                Integer.MAX_VALUE); // 内存缓存中单个图片的最大大小。

        //修改内存图片缓存数量，空间策略（这个方式有点恶心）
        Supplier<MemoryCacheParams> mSupplierMemoryCacheParams = new Supplier<MemoryCacheParams>() {
            @Override
            public MemoryCacheParams get() {
                return bitmapCacheParams;
            }
        };

        //小图片的磁盘配置
        DiskCacheConfig diskSmallCacheConfig = DiskCacheConfig.newBuilder(context)
                .setBaseDirectoryPath(context.getApplicationContext().getCacheDir())//缓存图片基路径
                .setBaseDirectoryName(IMAGE_PIPELINE_SMALL_CACHE_DIR)//文件夹名
//                .setCacheErrorLogger(cacheErrorLogger)//日志记录器用于日志错误的缓存。
//                .setCacheEventListener(cacheEventListener)//缓存事件侦听器。
//                .setDiskTrimmableRegistry(diskTrimmableRegistry)//类将包含一个注册表的缓存减少磁盘空间的环境。
                .setMaxCacheSize(MAX_SMALL_DISK_CACHE_SIZE)//默认缓存的最大大小。
                .setMaxCacheSizeOnLowDiskSpace(MAX_SMALL_DISK_LOW_CACHE_SIZE)//缓存的最大大小,使用设备时低磁盘空间。
                .setMaxCacheSizeOnVeryLowDiskSpace(MAX_SMALL_DISK_VERYLOW_CACHE_SIZE)//缓存的最大大小,当设备极低磁盘空间
//                .setVersion(version)
                .build();

        //默认图片的磁盘配置
        DiskCacheConfig diskCacheConfig = DiskCacheConfig.newBuilder(context)
                .setBaseDirectoryPath(new File(imgPath))//缓存图片基路径
                .setBaseDirectoryName(IMAGE_PIPELINE_CACHE_DIR)//文件夹名
                .setMaxCacheSize(MAX_DISK_CACHE_SIZE)//默认缓存的最大大小。
                .setMaxCacheSizeOnLowDiskSpace(MAX_DISK_CACHE_LOW_SIZE)//缓存的最大大小,使用设备时低磁盘空间。
                .setMaxCacheSizeOnVeryLowDiskSpace(MAX_DISK_CACHE_VERYLOW_SIZE)//缓存的最大大小,当设备极低磁盘空间
                .build();

        //缓存图片配置
//        ImagePipelineConfig.Builder configBuilder = ImagePipelineConfig.newBuilder(context)
//              .setAnimatedImageFactory(AnimatedImageFactory animatedImageFactory)//图片加载动画
//              .setBitmapMemoryCacheParamsSupplier(mSupplierMemoryCacheParams)//内存缓存配置（一级缓存，已解码的图片）
//              .setCacheKeyFactory(cacheKeyFactory)//缓存Key工厂
//              .setEncodedMemoryCacheParamsSupplier(encodedCacheParamsSupplier)//内存缓存和未解码的内存缓存的配置（二级缓存）
//              .setExecutorSupplier(executorSupplier)//线程池配置
//              .setImageCacheStatsTracker(imageCacheStatsTracker)//统计缓存的命中率
//              .setImageDecoder(ImageDecoder imageDecoder) //图片解码器配置
//              .setIsPrefetchEnabledSupplier(Supplier<Boolean> isPrefetchEnabledSupplier)//图片预览（缩略图，预加载图等）预加载到文件缓存
//              .setMainDiskCacheConfig(diskCacheConfig)//磁盘缓存配置（总，三级缓存）
//              .setMemoryTrimmableRegistry(memoryTrimmableRegistry) //内存用量的缩减,有时我们可能会想缩小内存用量。比如应用中有其他数据需要占用内存，不得不把图片缓存清除或者减小 或者我们想检查看看手机是否已经内存不够了。
//              .setNetworkFetchProducer(networkFetchProducer)//自定的网络层配置：如OkHttp，Volley
//              .setPoolFactory(poolFactory)//线程池工厂配置
//              .setProgressiveJpegConfig(progressiveJpegConfig)//渐进式JPEG图
//              .setRequestListeners(requestListeners)//图片请求监听
//              .setResizeAndRotateEnabledForNetwork(boolean resizeAndRotateEnabledForNetwork)//调整和旋转是否支持网络图片
//              .setSmallImageDiskCacheConfig(diskSmallCacheConfig);//磁盘缓存配置（小图片，可选～三级缓存的小图优化缓存）

        OkHttpClient okHttpClient = new OkHttpClient();
        ImagePipelineConfig config = OkHttpImagePipelineConfigFactory
                .newBuilder(this, okHttpClient)
                .setBitmapMemoryCacheParamsSupplier(mSupplierMemoryCacheParams)
                .setMainDiskCacheConfig(diskCacheConfig)
                .setSmallImageDiskCacheConfig(diskSmallCacheConfig)
                .build();

        Fresco.initialize(this, config);
    }


}
